package com.ruoyi.oos.startstop.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.oos.startstop.domain.StartstopRecord;
import com.ruoyi.oos.startstop.mapper.StartstopRecordMapper;
import com.ruoyi.oos.startstop.service.IStartstopRecordCalService;
import com.ruoyi.oos.tag.domain.TagConfig;
import com.ruoyi.oos.tag.mapper.TagConfigMapper;
import com.ruoyi.oos.tag.mapper.TagGroupMapper;

import cn.hz.pi.api.PiApiUtil;
import cn.hz.pi.api.util.DateUtil;
import cn.hz.pi.api.util.TagValue;

@Service
public class StartstopCalServiceImpl  implements IStartstopRecordCalService{
	
	@Autowired
	TagConfigMapper configMapper;
	@Autowired
	StartstopRecordMapper recordMapper;
	
	@Autowired
	TagGroupMapper groupMapper;
	
	
	public void calStartstopRecord(String startTime,String endTime) {
		TagConfig config = new TagConfig();
		config.setCalctype("2");
		 //循环测点
		// this.saveStartstopRecord("kaiguantag1","4",startTime,endTime);
		
		   List<TagConfig> configList = configMapper.selectTagConfigList(config);
		   for (TagConfig tagConfig : configList) {
			   String tagName = tagConfig.getPitagname();
			   String name = tagConfig.getTagname();
			   String limitType =tagConfig.getLimittype();
			    this.saveStartstopRecord(name,tagName,limitType,startTime,endTime);
			  
			   //DCS1.FDFBRUN
			   
		  }
	}

	private void saveStartstopRecord(String name,String tagName, String limitType,String startTime,String endTime1) {
		Long allTime = DateUtil.minBetween(startTime,endTime1);//总时间
		List<TagValue> list  =PiApiUtil.getValueList(null,tagName,startTime,endTime1, allTime.intValue());//所有的pi里的值
		TagConfig  config = new TagConfig();
		config.setPitagname(tagName);
		config.setLimittype("4");
		List<Map<String,Object>> tagList2 = configMapper.selectTagConfigListDetail2(config);
		this.saveRecord(name,tagName, tagList2, list, limitType,startTime,endTime1);
	}

	private void saveRecord(String name,String tagName, List<Map<String, Object>> tagList2, List<TagValue> list, String limitType,String startTime,String endTime1) {
		this.deleteRecord(tagName, startTime, endTime1,limitType);//删除
		for (Map<String, Object> map : tagList2) {
			String type = map.get("type").toString();
			List<StartstopRecord> upList =new ArrayList<>();
			Float limitval =Float.parseFloat(map.get("limitval").toString());
			 upList =this.getUpList(list,limitval,tagName);
			 Long groupId =Long.parseLong(map.get("groupid").toString());
				Long tagId =Long.parseLong(map.get("id").toString());
				String calctype = map.get("calctype").toString();
				String limittype = map.get("limittype").toString();
				String groupname = groupMapper.selectTagGroupById(groupId).getGroupname();
					for (StartstopRecord recordBean : upList) {
						recordBean.setGroupid(groupId);
						recordBean.setTagid(tagId);
						if(recordBean.getEndtime() !=null) {
							recordBean.setTimes(DateUtil.minDateBetween(recordBean.getStarttime(),recordBean.getEndtime()));
						}
						recordBean.setCalctype(calctype);
						recordBean.setLimittype(limittype);
						recordBean.setDatatype(type);
						recordBean.setTagname(tagName);
						recordBean.setTagname1(name);
						recordBean.setGroupname(groupname);
						recordMapper.insertStartstopRecord(recordBean);
					}
			 
		}
		
		
	}
	
	public void deleteRecord(String tagName,String startTime,String endTime,String limitType) {
		StartstopRecord record = new StartstopRecord();
		record.setTagname(tagName);
		record.setLimittype(limitType);
		record.setStarttime(DateUtils.parseDate(startTime));
		record.setEndtime(DateUtils.parseDate(endTime));
		recordMapper.deleteRecordByBeanNew(record);
	}
	
	/**
	 *   先判断当前是否开着，
	 *   如果开着，则不用问。
	 *   如果关了，取上一条，添加结束时间。
	 *  如果继续关着，不用问。
	 *  如果开了，添加一条记录，  添加开始时间，标记为开着
	 *  如果继续开着，判断之前标记为开着，则不用动。
	 *  如果关了，取上面的记录，添加结束时间。
	 *  如果继续关着，不用问。
	 *  
	 *   
	 * 
	 * @param list
	 * @param limitval
	 * @return
	 */
	public List<StartstopRecord> getUpList(List<TagValue> list,Float limitval,String tagName) {
		List<StartstopRecord> recordList = new ArrayList<>();
		StartstopRecord temp = new StartstopRecord();
		temp.setTagname(tagName);
		//	StartstopRecord  firstrecord = null;
		StartstopRecord  firstrecord=	recordMapper.selectMaxStartstopRecord(temp);
		TagValue end =list.get(list.size()-1);
		 int flag = 0;//标记为关着。
		 int bflag =0;//标记是否更新最后一条
		 StartstopRecord record  = null;
		if(firstrecord == null) {
			flag = 0;//标记为关着。
			record=	new StartstopRecord();
		}else if(firstrecord.getEndtime() ==null) {
			flag = 1;//标记为开着。
			bflag=1;
			record = firstrecord; 
		}else if (firstrecord.getEndtime() != null) {
			flag = 0;//标记为关着。
			record=	new StartstopRecord();
		}
		
				for (TagValue tagValue : list) {
					int value = tagValue.getState();//当前状态，如果是开着，
				if (value == limitval && flag == 0) {//如果开着，新加一条记录，标记为开。
					Date tagbeginTime = DateUtils.parseDate(tagValue.getTime());
					record.setStarttime(tagbeginTime);
					flag = 1;
				}
				else if ((value != limitval) && flag == 1 && -248 != value) {//如果关着，之前标记为开，则标记为关，填上结束时间。
					Date tagendTime = DateUtils.parseDate(tagValue.getTime());
					record.setEndtime(tagendTime);
					if(bflag == 1) {
						recordMapper.updateStartstopRecord(record);
						bflag =0;
					}else {
						recordList.add(record);
					}
					record = new StartstopRecord();
					flag = 0;
					
				}
				}
//				if ((end.getState() == limitval || -248 == end.getState() ) && record.getId()==null) {//如果结束时开始关着的，则填写结束时间？这个用于
//					Date tagendTime = DateUtils.parseDate(end.getTime());
//				    	 record.setEndtime(tagendTime);
//					recordList.add(record);
//				}
		 return recordList;
	}
	
	

}
